home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1994 / MacHack 1994.toast / MacHack™ 1987-1994 / MacHack™ '91 / '91 Attendee Contributions / Rotate Src / Rotate.ac < prev    next >
Encoding:
Text File  |  1991-06-20  |  14.9 KB  |  553 lines  |  [TEXT/MPS ]
  1. ;    Bitmap rotation routines
  2.  
  3. ;    Copyright © 1989 Bob Spence
  4. ;    All rights reserved.
  5.  
  6.     INCLUDE 'QuickEqu.a'
  7.     INCLUDE 'Traps.a'
  8.  
  9. ;
  10. ; Rotation States
  11. ;
  12. ;    no rotation        rotate 180
  13. ;    (0)    1 2            (X)    4 3
  14. ;        3 4                2 1
  15. ;
  16. ;    mirror            mirror
  17. ;    horizontal        vertical
  18. ;    (H)    2 1            (V)    3 4
  19. ;        4 3                1 2
  20. ;
  21. ;    rotate left        rotate right
  22. ;    (L)    2 4            (R    3 1
  23. ;        1 3                4 2
  24. ;
  25. ;     flip left         flip right
  26. ;  (FL)    1 3           (FR)    4 2
  27. ;        2 4                3 1
  28. ;
  29.  
  30. ;
  31. ;    Rotation State Table
  32. ;
  33. ;              Rotate  Mirror  Mirror  Rotate  Rotate
  34. ;      State       180      Horiz       Vert       Left      Right        FL        FR
  35. ; 
  36. ;        0        X        H        V        L        R        FL        FR
  37. ;        H        V        0        X        FL        FR        L        R
  38. ;        V        H        X        0        FR        FL        R        L
  39. ;        X        0        V        H        R        L        FR        FL
  40. ;        L        R        FR        FL        X        0        H        V
  41. ;        R        L        FL        FR        0        X        V        H
  42. ;       FL        FR        R        L        V        H        0        X
  43. ;       FR        FL        L        R        H        V        X        0
  44. ;
  45.  
  46. ; typedef enum {Rot0, RotH, RotV, RotX,
  47. ;                RotL, RotR, RotFR, RotFL} RotationSw;
  48.  
  49. Rot0    EQU    0
  50. RotH    EQU    1
  51. RotV    EQU    2
  52. RotX    EQU    3
  53. RotL    EQU    4
  54. RotR    EQU    5
  55. RotFL    EQU    6
  56. RotFR    EQU    7
  57.  
  58. ; PROCEDURE CalcRotate(OldState, NewRotate: RotationSw): RotationSw;
  59. ; parameter offsets (in Pascal order)
  60. NEW_ROTATE    EQU 4+4
  61. OLD_STATE    EQU NEW_ROTATE+4
  62.  
  63.     EXPORT    CALC_ROTATE
  64. CALC_ROTATE    PROC
  65.     Link    A6,#0
  66.     Move.L    OLD_STATE(A6),D0     ; Get the rotation state
  67.     Lsl.W    #3,D0
  68.     Add.W    NEW_ROTATE(A6),D0 ; Apply the new rotation
  69.     And.W    #$3F,D0
  70.     Move.L    RotState,A0        ; Point to the transformation table
  71.     Move.B    (A0,D0.W),-2(A6) ; Return the resultant rotation state
  72.     Unlk    A6
  73.     Move.L    (sp)+,A0        ; Get return address and
  74.     Add.L    #8,sp            ; pop parameters off stack
  75.     Jmp        (A0)            ; for a Pascal style return
  76.  
  77. RotState    ; Indexed by state and rotation, giving new rotation state
  78.     DC.B     Rot0, RotX, RotH, RotV, RotL, RotR, RotFL,RotFR
  79.     DC.B    RotH, RotV, Rot0, RotX, RotFL,RotFR,RotL, RotR
  80.     DC.B    RotV, RotH, RotX, Rot0, RotFR,RotFL,RotR, RotL
  81.     DC.B    RotX, Rot0, RotV, RotH, RotR, RotL, RotFR,RotFL
  82.     DC.B    RotL, RotR, RotFR,RotFL,RotX, Rot0, RotH, RotV
  83.     DC.B    RotR, RotL, RotFL,RotFR,Rot0, RotX, RotV, RotH    
  84.     DC.B    RotFL,RotFR,RotR, RotL, RotV, RotH, Rot0, RotX
  85.     DC.B    RotFR,RotFL,RotL, RotR, RotH, RotV, RotX, Rot0
  86.  
  87.     ENDPROC
  88.     
  89. ;    The user may also select rotation of the image 90° left, right, or
  90. ;     180° as well as mirroring of the image horizontally and vertically.
  91.  
  92.  
  93.  
  94. ; Register usage
  95. ;    A0 = Input bitmap or current data pointer
  96. ;    A1 = Output bitmap or current data pointer
  97. ;    D0 & D1 = temp variables
  98. ;    D2..D7  = part of 16 word rotation matrix
  99.  
  100. ; Named register storage
  101.  
  102. InBase        EQU A2            ; Input BitMap row base address (when rotated)
  103. OutBase        EQU A2            ; Output BitMap row base address (when mirrored)
  104. InBytes        EQU A3            ; Input BitMap rowBytes
  105.  
  106. ; Local variable stack offsets
  107.  
  108. RowPtr        EQU    -4            ; Temp storage for output word pointer
  109. LowBound    EQU    RowPtr-4    ; Lowest output word address
  110. HiBound        EQU    LowBound-4    ; Highest output word address
  111. OutBytes    EQU    HiBound-2    ; Output BitMap rowBytes 
  112. InWords        EQU    OutBytes-2    ; Words in an input row (-1 for Dbra))
  113. InRows        EQU    InWords-2    ; Rows in the input BitMap
  114. OutRows        EQU    InRows-2    ; Rows in the output BitMap
  115. WordCnt        EQU    OutRows-2    ; Temp storage for Word loop counter
  116. xD0            EQU    WordCnt-2    ; Temp storage for D0 in D0..D7 data block
  117. LOCALSZ        EQU    xD0-2        ; Total space needed for local variables
  118.  
  119. ; The following Macros are used to:
  120. ;    Initialize the rotation loops
  121. ;    Load registers with input to transform
  122. ;    Transform the data
  123. ;    Loop thru the data as needed, and return
  124.  
  125. ;    
  126. ; Macros used to rotate a BitMap [left, right, flip left, flip right]
  127. ;
  128. ; Used by LOAD_REGS to fill a D register with the next 2 column words
  129.     MACRO
  130.     LOAD_REG    &Dreg,&swap
  131.     IF &swap = 'T' THEN
  132.     Swap    &Dreg            ; Put it into hi word
  133.     ENDIF
  134.     Move.W    (A0),&Dreg        ; Get a word
  135.     Add.L    InBytes,A0        ; Drop to next row
  136.     Swap    &Dreg            ; Put next into other word
  137.     Move.W    (A0),&Dreg        ; Get a word
  138.     Add.L    InBytes,A0        ; Drop to next row
  139.     IF &swap = 'F' THEN
  140.     Swap    &Dreg            ; Restore 1st word low, 2nd word hi
  141.     ENDIF
  142.     ENDM
  143.  
  144. ; Establish the tops of the 16 word block rotate loops and
  145. ; load a 16 word block of data to rotate in the D registers
  146.     MACRO
  147.     LOAD_REGS &Loop,&swap
  148.     Move.L    A1,RowPtr(A6)    ; Save output's word address
  149. &Loop.Col:                    ; Top of the column loop
  150.     Move.W    InWords(A6),D0    ; Word count to process, this row
  151. &Loop.Row:                    ; Top of the row loop
  152.     Move.W    D0,WordCnt(A6)    ; Save loop counter, we need D0
  153.     Move.L    A0,InBase        ; Save the current input address
  154.     ; generate LOAD_REG D0..D7
  155.     LCLA    &n
  156.     IF &swap = 'T' THEN
  157. &n    SETA    7
  158.     WHILE    &n >= 0 DO
  159.     LOAD_REG D&n,&swap 
  160. &n    SETA    &n - 1
  161.     ENDW
  162.     ELSE
  163. &n    SETA    0
  164.     WHILE    &n <= 7 DO
  165.     LOAD_REG D&n,&swap 
  166. &n    SETA    &n + 1
  167.     ENDW
  168.     ENDIF
  169.     Add.L    #2,InBase        ; Point to next input word block
  170.     Move.L    InBase,A0        ; Restore the start of input
  171.     ENDM
  172.  
  173. ; Used by END_ROTATE to store the column words
  174.     MACRO
  175.     STORE_REG    &Dreg,&AdSb1,&Loop,&swap
  176.     IF &swap = 'T' THEN
  177.     Swap    &Dreg            ; Put it into hi word
  178.     ENDIF
  179.     Move.W    &Dreg,(A1)        ; Store the rotated output word
  180.     &AdSb1..W OutBytes(A6),A1 ; Add/Subtract to next output row
  181.     IF &AdSb1 = 'Add' THEN
  182.     CMP.L    HiBound(A6),A1    ; If slop on the bottom been exceeded,
  183.     BGT        &Loop.End        ;  we will go to next column
  184.     ELSE
  185.     CMP.L    LowBound(A6),A1    ; If slop on the bottom been rotated up,
  186.     BLT        &Loop.End        ;  we will go to next column
  187.     ENDIF
  188.     Swap    &Dreg            ; Get the other word
  189.     Move.W    &Dreg,(A1)        ; Store the rotated output word
  190.     &AdSb1..W OutBytes(A6),A1 ; Add/Subtract to next output row
  191.     IF &AdSb1 = 'Add' THEN
  192.     CMP.L    HiBound(A6),A1    ; If slop on the bottom been exceeded,
  193.     BGT        &Loop.End        ;  we will go to next column
  194.     ELSE
  195.     CMP.L    LowBound(A6),A1    ; If slop on the bottom been rotated up,
  196.     BLT        &Loop.End        ;  we will go to next column
  197.     ENDIF
  198.     ENDM
  199.  
  200. ; Rotate each bit of word in D&in into the D&out result word
  201.     MACRO
  202.     RotREG &in,&out,&swapin,&swapout
  203.     LCLA    &rin
  204.     LCLA    &rout
  205. &rin SETA    &in / 2
  206. &rout SETA    &out / 2
  207.     LCLA    &diff
  208. &diff SETA    &out - &in
  209.     IF &diff >= 0 THEN
  210.     IF &swapin = 'T' THEN
  211.     Addx.W    D0,D0            ; Get an input bit
  212.     ELSE
  213.     Addx.W    D&rin,D&rin        ; Get an input bit
  214.     ENDIF
  215.     IF &swapout = 'T' THEN
  216.     Swap    D&rout            ; Get the 2nd, hi word
  217.     Addx.W    D&rout,D&rout    ; Set the output bit
  218.     Swap    D&rout            ; Restore hi and lo words
  219.     ELSE
  220.     Addx.W    D&rout,D&rout    ; Set the output bit
  221.     ENDIF
  222.     ENDIF
  223.     ENDM
  224.  
  225. ; Get 16 bits from the 16 Dx words, rotated into D0
  226.     MACRO
  227.     ROT_REGS
  228.     ; generate RotREG D0..D7
  229.     LCLA    &in
  230.     LCLA    &out
  231.     LCLA    &x
  232. &in    SETA    0
  233.     WHILE    &in <= 15 DO
  234. &out SETA    0
  235. &x SETA        &in / 2
  236.     Addx.W    D&x,D&x            ; init the x flag, but insert some trash
  237.     WHILE    &out <= 15 DO
  238.     RotREG    &in,&out,F,F
  239. &out SETA    &out + 1
  240.     RotREG    &in,&out,F,T
  241. &out SETA    &out + 1
  242.     ENDW
  243. &in SETA    &in + 1
  244.     Addx.W    D&x,D&x            ; clear the x flag trash
  245. &out SETA    0
  246.     Swap    D&x
  247.     Move.W    D0,xD0(A6)
  248.     Move.W    D&x,D0
  249.     Swap    D&x
  250.     Addx.W    D0,D0                ; init the x flag, but insert some trash
  251.     WHILE    &out <= 15 DO
  252.     RotREG    &in,&out,T,F
  253. &out SETA    &out + 1
  254.     RotREG    &in,&out,T,T
  255. &out SETA    &out + 1
  256.     ENDW
  257. &in SETA    &in + 1
  258.     Addx.W    D0,D0                ; clear the x flag trash
  259.     Swap    D&x
  260.     Move.W    D0,D&x
  261.     Move.W    xD0(A6),D0
  262.     Swap    D&x
  263.     ENDW
  264.     ENDM
  265.  
  266. ; Check the word, row and column loops, cleanup, and return
  267.     MACRO
  268.     END_ROTATE &Loop,&AdSb1,&AdSb2,&swap
  269.     LCLA    &n
  270. &n    SETA    0
  271.     WHILE    &n <= 7 DO
  272.     STORE_REG D&n,&AdSb1,&Loop,&swap
  273. &n    SETA    &n + 1
  274.     ENDW
  275. &Loop.End
  276.     Move.W    WordCnt(A6),D0    ; Get row width word loop count
  277.     Dbra    D0,&Loop.Row
  278.     &AdSb2..L #2,RowPtr(A6)    ; Add/Sub to next output word of row
  279.     Move.L    RowPtr(A6),A1    ; Restore to start of next output word
  280.     Move.L    InBytes,D0        ; Get the input rowBytes
  281.     Lsl.L    #4,D0            ; A0 has wrapped to 1st column, 2nd word
  282.     Sub.L    InBytes,D0        ; so offset = 15 * InBytes
  283.     Add.L    D0,A0            ; Point to next A0 in word 15 rows beyond
  284.     Sub.W    #16,InRows(A6)    ; Drop down to rotate next 16 rows
  285.     Bgt        &Loop.Col        ; When the rows are zero, we're done
  286.     ENDM
  287. ;
  288. ; Macros to mirror BitMaps [horizontal, vertical, 180°, null]
  289. ;
  290. ; Establish the tops of the mirroring loops
  291.     MACRO
  292.     GET_REG &Loop
  293. &Loop.Col:
  294.     Move.L    A1,OutBase        ; Save the start of output
  295.     Move.W    D1,D2            ; Set the Width loop count
  296. &Loop.Row:
  297.     ENDM
  298.  
  299. ; Transfer a word from input to output, unchanged
  300.     MACRO
  301.     GET_WORD    
  302.     Move.W    (A0)+,D0        ; Just get an input word, it's Ok as is
  303.     Move.W    D0,(A1)+        ; Store the word
  304.     ENDM
  305.  
  306. ; Transfer a word from input to output, bits reversed
  307.     MACRO
  308.     REVERSE_REG    
  309.     Move.W    (A0)+,D3        ; Reverse the 16 bits in word D3 
  310.     LCLA    &n
  311. &n    SETA    0
  312.     WHILE    &n <= 15 DO
  313.     Roxr.W    #1,D3            ; Take a bit from the right
  314.     Roxl.W    #1,D0            ;  and insert it to the left
  315. &n    SETA    &n + 1
  316.     ENDW
  317.     Move.W    D0,-(A1)        ; Store the word
  318.     ENDM
  319.  
  320. ; Check the word, row and column loops, cleanup, and return
  321.     MACRO
  322.     END_MIRROR &Loop,&ASub
  323.                             ; Loop,Add/Sub
  324.     Dbra    D2,&Loop.Row    ; Loop thru row's width
  325.     Move.L    OutBase,A1        ; Restore to start of row
  326.     &ASub..L InBytes,A1        ; Add/Sub to next row
  327.     Sub.W    #1,InRows(A6)    ; Drop to next row
  328.     Bgt.s    &Loop.Col        ; When the rows are zero, we're done
  329.     ENDM
  330.  
  331. ; Shift words left by the slop bits    
  332.     MACRO
  333.     SHIFT_WORDS
  334.     LCLA    &n
  335. &n    SETA    0
  336.     WHILE    &n <= 7 DO
  337.     Move.W    -(A0),D0    ; Get a word in the low word
  338.     Rol.L    D4,D0        ; Shift out the slop bits, round in good ones
  339.     Move.W    D0,(A0)        ; Store good word
  340.     Rol.L    D3,D0        ; Shift remaining good bits to top of long word
  341. &n    SETA    &n + 1
  342.     ENDW
  343.     ENDM    
  344.  
  345. doROT_REGS     PROC
  346.     ROT_REGS
  347.     Rts
  348.     ENDPROC
  349.  
  350. ;
  351. ; The bit rotation routine
  352. ; PROCEDURE Rotate (sourceMap, destMap: bitMap);
  353. ;
  354. ; Initialize loops, jump to specific rotation macros, and return
  355. ;
  356. ; parameter offsets (in Pascal order)
  357. DEST_MAP    EQU 4+4
  358. SOURCE_MAP    EQU DEST_MAP+4
  359. ROTATION    EQU SOURCE_MAP+4
  360.  
  361. Btop         EQU  D1     ; Some BitMap bounds Rect defines
  362. Bleft        EQU  D2    
  363. Bbottom        EQU  D3
  364. Bright        EQU  D4
  365.  
  366.     EXPORT    ROTATE
  367. ROTATE    PROC
  368.     Link    A6,#LOCALSZ              ; Allocate temporary storage
  369.     Movem.L    D2-D7/A2-A5,-(sp)     ; D0-D1/A0-A1 are scratch in Pascal and C
  370.     Move.L    SOURCE_MAP(A6),A2     ; Get the source BitMap address
  371.     Move.L    DEST_MAP(A6),A1          ; Get the destination BitMap address
  372.     Moveq    #0,D0
  373.     Move.L    D0,D1
  374.     Move.W    rowBytes(A2),D1        ; Get the input rowBytes
  375.     Move.L    D1,InBytes            ; Set the row byte count
  376.     Lsr.W    #1,D1                ; Convert to words
  377.     Sub.W    #1,D1                ;  minus 1 (for Dbra)
  378.     Move.W    D1,InWords(A6)
  379.     Movem.W    bounds(A2),D1-D4    ; Get the source bounds Rect
  380.     Move.W    Bbottom,D0
  381.     Sub.W    Btop,D0
  382.     Move.W    D0,InRows(A6)        ; Set the input number of rows
  383.     Cmp.B    #RotL,ROTATION(A6)    ; Is the destination not rotated
  384.     Blt.s    NoRotate
  385.     Sub.W    Bright,D0            ; Rotate the bounds Rect
  386.     Add.W    Bleft,D0            ; (Bbottom - Btop) - (Bright - Bleft);
  387.     Sub.W    D0,Bbottom
  388.     Add.W    D0,Bright
  389. NoRotate
  390.     Movem.W    D1-D4,bounds(A1) ; Set the destination bounds Rect
  391.     Move.W    Bbottom,D5
  392.     Sub.W    Btop,D5
  393.     Move.W    D5,OutRows(A6)    ; Set the destination row count
  394.  
  395.     Move.W    Bright,D6        ; Compute rowBytes
  396.     Sub.W    Bleft,D6        ;  forced to word boundary
  397.     Add.W    #15,D6
  398.     Lsr.W    #4,D6            ; (Bright - Bleft + 15) / 16) * 2
  399.     Lsl.W    #1,D6
  400.     Move.W    D6,rowBytes(A1)    ; Set the destination rowBytes
  401.     Move.W    D6,OutBytes(A6)
  402.     Mulu    D6,D5            ; Compute destination map size
  403.     Addq    #2,D5            ;  rowBytes * (Bbottom - Btop)
  404.     Move.L    D5,D0            ;  plus a fudge word for slop bits
  405.     Addq    #2,D0            ;  plus one more slop word
  406.     _NewPtr                    ; allocate space for bitmap
  407.     Move.L    A0,baseAddr(A1)    ; Set the destination upper left corner
  408.     Move.L    A0,LowBound(A6)    ; Save lowest output address
  409.     Add.L    D5,A0            ; Point beyond lower right corner
  410.     Move.L    A0,HiBound(A6)    ; Save Highest output address
  411.     Move.L    baseAddr(A2),A0    ; Get the source upper left corner
  412.     Move.W    InWords(A6),D1    ; Set D1 for GET_REG Macro
  413.  
  414.     Moveq    #0,D0
  415.     Move.B    ROTATION(A6),D0    ; Get the rotation type
  416.     And.W    #7,D0            ; Force to legal, We provide no error check, yet
  417.     Add.W    D0,D0
  418.     Move.W    Jump_Table(PC,D0),D0
  419.     Jmp        Jump_Table(PC,D0)
  420.  
  421. Jump_Table
  422.     DC.W    (Rotate_0 - Jump_Table)
  423.     DC.W    (Rotate_H - Jump_Table)
  424.     DC.W    (Rotate_V - Jump_Table)
  425.     DC.W    (Rotate_X - Jump_Table)
  426.     DC.W    (Rotate_L - Jump_Table)
  427.     DC.W    (Rotate_R - Jump_Table)
  428.     DC.W    (Rotate_FL - Jump_Table)
  429.     DC.W    (Rotate_FR - Jump_Table)
  430. ;
  431. ; The Rotation and Mirror Routines
  432. ;
  433. Rotate_0                        
  434.     Move.L        LowBound(A6),A1    ; Point to upper left corner
  435.     GET_REG        loop0
  436.     GET_WORD
  437.     END_MIRROR    loop0,Add
  438.     Bra            Exit_Rotate
  439.  
  440. Rotate_H
  441.     Move.L        LowBound(A6),A1    ; Point beyond upper right corner
  442.     Add.W        InBytes,A1        ; for predecrement of A1 in data stores
  443.     GET_REG        loopH
  444.     REVERSE_REG
  445.     END_MIRROR    loopH,Add
  446.     Bra            Shift_Left        ; shift image left slop bits
  447.  
  448. Rotate_V
  449.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  450.     Sub            #2,A1            ; and never slop adjust
  451.     Sub.W        InBytes,A1
  452.     GET_REG        loopV
  453.     GET_WORD
  454.     END_MIRROR    loopV,Sub
  455.     Bra            Exit_Rotate
  456.  
  457. Rotate_X
  458.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  459.                                 ; for predecrement of A1 in data stores
  460.     Move.L        DEST_MAP(A6),A4          ; Get the destination BitMap address
  461.     Move.W        bounds+right(A4),D3
  462.     Sub.W        bounds+left(A4),D3    ; Number of slop bits on the left
  463.     And.W        #$0F,D3                ; Any slop bits to shift in a word ?
  464.     Sub            #2,A1            ; We don't slop adjust later in Shift_Left
  465.     GET_REG        loopX
  466.     REVERSE_REG
  467.     END_MIRROR    loopX,Sub
  468.     Bra            Shift_Left        ; shift image left slop bits
  469.  
  470. Rotate_L
  471.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  472.     Sub.W        OutBytes(A6),A1    ; Point to lower left corner
  473.     Sub            #2,A1            ; and never slop adjust
  474.     LOAD_REGS    loopL,F
  475.     Jsr            doROT_REGS    ;    l,l
  476.     END_ROTATE    loopL,Sub,Add,T
  477.     Bra            Exit_Rotate
  478.  
  479. Rotate_R
  480.     Move.L        LowBound(A6),A1
  481.     Add.W        OutBytes(A6),A1
  482.     Sub.L        #2,A1            ; Point to upper right corner
  483.     LOAD_REGS    loopR,T
  484.     Jsr            doROT_REGS    ;    l,r
  485.     END_ROTATE    loopR,Add,Sub,F
  486.     Bra            Shift_Left        ; shift image left slop bits
  487.  
  488. Rotate_FL
  489.     Move.L        LowBound(A6),A1    ; Point to upper left corner
  490.     LOAD_REGS    loopFL,F
  491.     Jsr            doROT_REGS    ;    l,l
  492.     END_ROTATE    loopFL,Add,Add,F
  493.     Bra            Exit_Rotate
  494.  
  495. Rotate_FR
  496.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  497.     Sub.L        #2,A1            ; Point to lower right corner
  498.     Move.L        DEST_MAP(A6),A4          ; Get the destination BitMap address
  499.     Move.W        bounds+right(A4),D3
  500.     Sub.W        bounds+left(A4),D3    ; Number of slop bits on the left
  501.     And.W        #$0F,D3                ; Any slop bits to shift in a word ?
  502.     Sub            #2,A1            ; We don't slop adjust later in Shift_Left
  503.     LOAD_REGS    loopFR,T
  504.     Jsr            doROT_REGS    ;    l,r
  505.     END_ROTATE    loopFR,Sub,Sub,T
  506. ;;    Bra            Shift_Left        ; shift image left slop bits
  507.  
  508. ;
  509. ; Routines to shift the BitMap data for any slop around
  510. ; the edges caused by images having heights or widths
  511. ; which are not on word boundaries. Some rotations cause 
  512. ; extra columns or rows to be generated to the left or top
  513. ; of the BitMap, we now must push the image up to the topLeft
  514. ; corner of the Bitmap.
  515. ;
  516. ; Shift left the output BitMap any slop columns
  517. Shift_Left
  518.     Move.L    DEST_MAP(A6),A4          ; Get the destination BitMap address
  519.     Move.W    bounds+right(A4),D3
  520.     Sub.W    bounds+left(A4),D3    ; Number of slop bits on the left
  521.     And.W    #$0F,D3                ; Any slop bits to shift in a word ?
  522.     Beq.s    Exit_Rotate
  523.     Move.L    baseAddr(A4),A0    ; Get the destination upper left corner
  524.     Move.W    OutBytes(A6),D1
  525.     Move.W    OutRows(A6),D2    ; Get the output rows
  526.     Mulu    D1,D2            ; Get total byte size
  527.     Add.L    D2,A0            ; Point to lower right corner
  528.     Lsr.W    #1,D2            ; Convert to words
  529.     Moveq    #16,D4
  530.     Sub.W    D3,D4            ; Number of slop bits
  531.     Move.L    D2,D5
  532.     Lsr.L    #3,D5            ; Loop count in blocks of 8 words
  533.     Move.W    D2,D1
  534.     Neg.W    D1                ; To jump into the loop doing the 
  535.     And.W    #7,D1            ;  block boundary remainder first
  536.     Beq.s    Bit_Loop_End
  537.     Asl.W    #3,D1            ; Multiply by code block size
  538.     Jmp        Bit_loop(PC,D1)    ; Jump into the loop, part way
  539. Bit_loop
  540.     SHIFT_WORDS
  541. Bit_Loop_End
  542.     Dbra    D5,Bit_loop
  543.     
  544. Exit_Rotate
  545.     Movem.L    (sp)+,D2-D7/A2-A5
  546.     Unlk    A6
  547.     Move.L    (sp)+,A0        ; Get return address and
  548.     Add.L    #10,sp            ; pop parameters off stack
  549.     Jmp        (A0)            ; for a Pascal style return
  550.     ENDPROC
  551.     
  552.     END
  553.